CodeMirror.defineMode("xml", function(config, parserConfig) {
    var indentUnit = config.indentUnit;
    var Kludges = parserConfig.htmlMode ? {
        autoSelfClosers: { "br": true, "img": true, "hr": true, "link": true, "input": true,
            "meta": true, "col": true, "frame": true, "base": true, "area": true
        },
        doNotIndent: { "pre": true, "!cdata": true },
        allowUnquoted: true
} : { autoSelfClosers: {}, doNotIndent: { "!cdata": true }, allowUnquoted: false };
        var alignCDATA = parserConfig.alignCDATA;

        // Return variables for tokenizers
        var tagName, type;

        function inText(stream, state) {
            function chain(parser) {
                state.tokenize = parser;
                return parser(stream, state);
            }

            var ch = stream.next();
            if (ch == "<") {
                if (stream.eat("!")) {
                    if (stream.eat("[")) {
                        if (stream.match("CDATA[")) return chain(inBlock("atom", "]]>"));
                        else return null;
                    }
                    else if (stream.match("--")) return chain(inBlock("comment", "-->"));
                    else if (stream.match("DOCTYPE", true, true)) {
                        stream.eatWhile(/[\w\._\-]/);
                        return chain(inBlock("meta", ">"));
                    }
                    else return null;
                }
                else if (stream.eat("?")) {
                    stream.eatWhile(/[\w\._\-]/);
                    state.tokenize = inBlock("meta", "?>");
                    return "meta";
                }
                else {
                    type = stream.eat("/") ? "closeTag" : "openTag";
                    stream.eatSpace();
                    tagName = "";
                    var c;
                    while ((c = stream.eat(/[^\s\u00a0=<>\"\'\/?]/))) tagName += c;
                    state.tokenize = inTag;
                    return "tag";
                }
            }
            else if (ch == "&") {
                stream.eatWhile(/[^;]/);
                stream.eat(";");
                return "atom";
            }
            else {
                stream.eatWhile(/[^&<{#]/);
                return null;
            }
        }

        function inTag(stream, state) {
            var ch = stream.next();
            if (ch == ">" || (ch == "/" && stream.eat(">"))) {
                state.tokenize = inText;
                type = ch == ">" ? "endTag" : "selfcloseTag";
                return "tag";
            }
            else if (ch == "=") {
                type = "equals";
                return null;
            }
            else if (/[\'\"]/.test(ch)) {
                state.tokenize = inAttribute(ch);
                return state.tokenize(stream, state);
            }
            else {
                stream.eatWhile(/[^\s\u00a0=<>\"\'\/?]/);
                return "word";
            }
        }

        function inAttribute(quote) {
            return function(stream, state) {
                while (!stream.eol()) {
                    if (stream.next() == quote) {
                        state.tokenize = inTag;
                        break;
                    }
                }
                return "string";
            };
        }

        function inBlock(style, terminator) {
            return function(stream, state) {
                while (!stream.eol()) {
                    if (stream.match(terminator)) {
                        state.tokenize = inText;
                        break;
                    }
                    stream.next();
                }
                return style;
            };
        }

        var curState, setStyle;
        function pass() {
            for (var i = arguments.length - 1; i >= 0; i--) curState.cc.push(arguments[i]);
        }
        function cont() {
            pass.apply(null, arguments);
            return true;
        }

        function pushContext(tagName, startOfLine) {
            var noIndent = Kludges.doNotIndent.hasOwnProperty(tagName) || (curState.context && curState.context.noIndent);
            curState.context = {
                prev: curState.context,
                tagName: tagName,
                indent: curState.indented,
                startOfLine: startOfLine,
                noIndent: noIndent
            };
        }
        function popContext() {
            if (curState.context) curState.context = curState.context.prev;
        }

        function element(type) {
            if (type == "openTag") { curState.tagName = tagName; return cont(attributes, endtag(curState.startOfLine)); }
            else if (type == "closeTag") {
                var err = false;
                if (curState.context) {
                    err = curState.context.tagName != tagName;
                    popContext();
                } else {
                    err = true;
                }
                if (err) setStyle = "error";
                return cont(endclosetag(err));
            }
            else if (type == "string") {
                if (!curState.context || curState.context.name != "!cdata") pushContext("!cdata");
                if (curState.tokenize == inText) popContext();
                return cont();
            }
            else return cont();
        }
        function endtag(startOfLine) {
            return function(type) {
                if (type == "selfcloseTag" ||
          (type == "endTag" && Kludges.autoSelfClosers.hasOwnProperty(curState.tagName.toLowerCase())))
                    return cont();
                if (type == "endTag") { pushContext(curState.tagName, startOfLine); return cont(); }
                return cont();
            };
        }
        function endclosetag(err) {
            return function(type) {
                if (err) setStyle = "error";
                if (type == "endTag") return cont();
                return pass();
            }
        }

        function attributes(type) {
            if (type == "word") { setStyle = "attribute"; return cont(attributes); }
            if (type == "equals") return cont(attvalue, attributes);
            return pass();
        }
        function attvalue(type) {
            if (type == "word" && Kludges.allowUnquoted) { setStyle = "string"; return cont(); }
            if (type == "string") return cont(attvaluemaybe);
            return pass();
        }
        function attvaluemaybe(type) {
            if (type == "string") return cont(attvaluemaybe);
            else return pass();
        }

        return {
            startState: function() {
                return { tokenize: inText, cc: [], indented: 0, startOfLine: true, tagName: null, context: null };
            },

            token: function(stream, state) {
                if (stream.sol()) {
                    state.startOfLine = true;
                    state.indented = stream.indentation();
                }
                if (stream.eatSpace()) return null;

                setStyle = type = tagName = null;
                var style = state.tokenize(stream, state);
                if ((style || type) && style != "comment") {
                    curState = state;
                    while (true) {
                        var comb = state.cc.pop() || element;
                        if (comb(type || style)) break;
                    }
                }
                state.startOfLine = false;
                return setStyle || style;
            },

            indent: function(state, textAfter) {
                var context = state.context;
                if (context && context.noIndent) return 0;
                if (alignCDATA && /<!\[CDATA\[/.test(textAfter)) return 0;
                if (context && /^<\//.test(textAfter))
                    context = context.prev;
                while (context && !context.startOfLine)
                    context = context.prev;
                if (context) return context.indent + indentUnit;
                else return 0;
            },

            compareStates: function(a, b) {
                if (a.indented != b.indented || a.tagName != b.tagName) return false;
                for (var ca = a.context, cb = b.context; ; ca = ca.prev, cb = cb.prev) {
                    if (!ca || !cb) return ca == cb;
                    if (ca.tagName != cb.tagName) return false;
                }
            },

            electricChars: "/"
        };
    });

CodeMirror.defineMIME("application/xml", "xml");
CodeMirror.defineMIME("text/html", {name: "xml", htmlMode: true});
